package com.zmz.Genericity;


import java.util.ArrayList;
import java.util.List;

/**
 * Create with IntelliT IDEA
 *
 * @Author: zhengmingzhe
 * @Date: 2022/09/08/11:33
 * @Description: 泛型测试
 */

public class GenericityTest {
    public static void main(String[] args) {
//        listTest();
//        listTest2();
//        listTest3();
//        listTest4();
//        listTest5();
//        listTest6();
//        listTest7();
        listTest8();
    }

    /*
     * @Description  此方法会报错 因为既添加了String,又添加了Integer类型
     * @Param
     * @return
     **/
    static void listTest() {
        List arrayList = new ArrayList();
        arrayList.add("aaaa");
        arrayList.add(100);

        for (int i = 0; i < arrayList.size(); i++) {
            String item = (String) arrayList.get(i);
            System.out.println("泛型测试:item = " + item);
        }
    }

    /*
     * @Description   在编译之后程序会采取去泛型化的措施,也就是说Java中的泛型，只在编译阶段有效。
     * @Param
     * @return
     **/
    static void listTest2() {
        List<String> stringArrayList = new ArrayList<String>();
        List<Integer> integerArrayList = new ArrayList<Integer>();

        Class classStringArrayList = stringArrayList.getClass();
        Class classIntegerArrayList = integerArrayList.getClass();

        if (classStringArrayList.equals(classIntegerArrayList)) {
            System.out.println("泛型测试,类型相同");
        } else {
            System.out.println("类型不相同");
        }
    }


    /*
     * @Description  泛型引用测试 ,泛型的类型参数只能是类类型（包括自定义类），不能是简单类型,比如这里用的Integer包装类
     *            不能对确切的泛型类型使用instanceof操作。如下面的操作是非法的，编译时会出错。instanceof 是用来判断它的左边是不是右边的实例
     * @Param
     * @return
     **/
    static void listTest3() {
        //传入的实参类型需与泛型的类型参数类型相同，即为Integer.
        Generic<Integer> genericInteger = new Generic<Integer>(123456);
        //传入的实参类型需与泛型的类型参数类型相同，即为String.
        Generic<String> genericString = new Generic<String>("key_vlaue");
        System.out.println("泛型测试 :key is " + genericInteger.getKey());
        System.out.println("泛型测试:key is " + genericString.getKey());
    }

    /*
     * @Description  泛型也可以不传入参数类型，这样就会失去泛型的限制作用
     * @Param
     * @return
     **/
    static void listTest4() {
        Generic generic = new Generic("111111");
        Generic generic1 = new Generic(4444);
        Generic generic2 = new Generic(55.55);
        Generic generic3 = new Generic(false);

        System.out.println("泛型测试：key is " + generic.getKey());
        System.out.println("泛型测试：key is " + generic1.getKey());
        System.out.println("泛型测试：key is " + generic2.getKey());
        System.out.println("泛型测试：key is " + generic3.getKey());
    }

    /*
     * @Description 泛型通配符  方法showKeyValue声明的?是类型实参
     * @Param
     * @return
     **/
    static void listTest5() {
        Generic generic = new Generic();
        Generic<Integer> gInteger = new Generic<Integer>(123);
        Generic<Number> gNumber = new Generic<Number>(456);
        generic.showKeyValue(gInteger);
        generic.showKeyValue(gNumber);

        // showKeyValue这个方法编译器会为我们报错：Generic<java.lang.Integer>
        // cannot be applied to Generic<java.lang.Number>
        // showKeyValue(gInteger);
    }

    /*
     * @Description  泛型可变参数测试
     * @Param
     * @return
     **/
    static void listTest6() {
        Generic generic = new Generic();
        generic.printMsg("111", 222, "aaaa", "2323.4", 55.55);
    }

    /*
     * @Description  泛型上边界测试，传入的参数类型必须为指定参数类型的子类
     * @Param
     * @return
     **/
    static void listTest7() {
        Generic generic = new Generic();
        Generic<String> generic1 = new Generic<String>("aaa");
        Generic<Integer> generic2 = new Generic<Integer>(2222);
        Generic<Float> generic3 = new Generic<Float>(2.4f);
        Generic<Double> generic4 = new Generic<Double>(2.56);

        //这一行代码编译器会提示错误，因为String类型并不是Number类型的子类
//        generic1.showKeyValue1(generic1);
        generic.showKeyValue1(generic1);
        generic2.showKeyValue1(generic2);
        generic3.showKeyValue1(generic3);
        generic4.showKeyValue1(generic4);
        generic1.showKeyValue2();
    }

    /*
     * @Description  泛型数组测试  能创建一个确切的泛型类型的数组
     * @Param
     * @return
     **/
    static void listTest8() {
        //下面这个例子不行
//        List<String>[] ls = new ArrayList<String>[10];
        //下面这个使用通配符是可以的
//        List<?>[] ls = new ArrayList<?>[10];
        //这样也是可以的
//        List<String>[] ls = new ArrayList[10];

        List<?>[] lsa = new List<?>[10]; // OK, array of unbounded wildcard type.
        Object o = lsa;
        Object[] oa = (Object[]) o;
        List<Integer> li = new ArrayList<Integer>();
        li.add(new Integer(3));
        oa[1] = li; // Correct.
        Integer i = (Integer) lsa[1].get(0); // OK
        System.out.println("泛型数组测试，数组第一个元素为：" + i);
    }
}
